import axios from 'axios'
import { ElMessage } from 'element-plus'

// 创建axios实例
const api = axios.create({
  baseURL: 'http://127.0.0.1:9001', // 使用相对路径以避免CORS问题
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器 - 添加认证token
api.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('userToken') || sessionStorage.getItem('userToken')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// 响应拦截器 - 统一处理错误
api.interceptors.response.use(
  (response) => {
    return response
  },
  (error) => {
    if (error.response) {
      const { status, data } = error.response
      
      switch (status) {
        case 401:
          ElMessage.error('登录已过期，请重新登录')
          // 清除本地存储的token
          localStorage.removeItem('userToken')
          sessionStorage.removeItem('userToken')
          // 跳转到登录页
          window.location.href = '/login'
          break
        case 403:
          ElMessage.error('没有权限访问该资源')
          break
        case 404:
          ElMessage.error('请求的资源不存在')
          break
        case 422:
          // 处理验证错误
          if (data.errors) {
            const errorMessages = Object.values(data.errors).flat()
            ElMessage.error(errorMessages.join(', '))
          } else {
            ElMessage.error(data.message || '参数验证失败')
          }
          break
        case 500:
          ElMessage.error('服务器内部错误，请稍后重试')
          break
        default:
          ElMessage.error(data.message || '请求失败')
      }
    } else if (error.request) {
      ElMessage.error('网络连接失败，请检查网络设置')
    } else {
      ElMessage.error('请求配置错误')
    }
    
    return Promise.reject(error)
  }
)

/**
 * 用户相关API接口
 */
export const userApi = {
  /**
   * 用户注册
   * @param {Object} registerData 注册数据
   * @param {string} registerData.phone 手机号
   * @param {string} registerData.nickname 昵称
   * @param {string} registerData.password 密码
   * @returns {Promise} 注册结果
   */
  async register(registerData) {
    try {
      console.log('正在发送注册请求到:', '/user/register');
      
      // 构建符合后端要求的User对象
      const userObj = {
        phone: registerData.phone,
        nickname: registerData.nickname,
        password: registerData.password,
        role: 0 // 固定值为0
      };
      
      console.log('注册数据:', {
        phone: userObj.phone,
        nickname: userObj.nickname,
        password: '***', // 隐藏密码
        role: userObj.role
      });
      
      const response = await api.post('/user/register', userObj);
      console.log('注册响应:', response);
      return response.data;
    } catch (error) {
      console.error('注册失败:', error);
      throw error;
    }
  },

  /**
   * 用户登录
   * @param {Object} loginData 登录数据
   * @returns {Promise} 登录结果
   */
  async login(loginData) {
    try {
      console.log('正在发送登录请求到:', '/user/login');
      console.log('请求数据:', loginData);
      
      // 构建查询参数
      const params = new URLSearchParams();
      for (const key in loginData) {
        params.append(key, loginData[key]);
      }
      
      const response = await api.get(`/user/login?${params.toString()}`);
      console.log('登录响应:', response);
      return response.data;
    } catch (error) {
      console.error('登录失败:', error);
      throw error;
    }
  },

  /**
   * 获取用户个人信息
   * @returns {Promise} 用户信息
   */
  async getProfile() {
    try {
      const response = await api.get('/user/profile')
      return response.data
    } catch (error) {
      console.error('获取用户信息失败:', error)
      throw error
    }
  },

  /**
   * 根据用户ID获取用户个人信息
   * @param {string} userId 用户ID
   * @returns {Promise} 用户信息
   */
  async getProfileById(userId) {
    try {
      const response = await api.get(`/user/profile/${userId}`)
      return response.data
    } catch (error) {
      console.error('获取用户信息失败:', error)
      throw error
    }
  },

  /**
   * 更新用户个人信息
   * @param {Object} userData 用户数据
   * @returns {Promise} 更新结果
   */
  async updateProfile(userData) {
    try {
      const response = await api.put('/user/profile/update', userData)
      return response.data
    } catch (error) {
      console.error('更新用户信息失败:', error)
      throw error
    }
  },

  /**
   * 上传用户头像
   * @param {File} file 头像文件
   * @returns {Promise} 上传结果
   */
  async uploadAvatar(file, userId) {
    try {
      const formData = new FormData()
      formData.append('file', file)
      formData.append('userId', userId)
      
      const response = await api.post('/user/upload/single', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      })
      return response.data
    } catch (error) {
      console.error('上传头像失败:', error)
      throw error
    }
  },

  /**
   * 修改密码
   * @param {Object} passwordData 密码数据
   * @returns {Promise} 修改结果
   */
  async changePassword(passwordData) {
    try {
      const response = await api.put('/user/change-password', passwordData)
      return response.data
    } catch (error) {
      console.error('修改密码失败:', error)
      throw error
    }
  },

  /**
   * 发送手机验证码
   * @param {string} phone 手机号
   * @returns {Promise} 发送结果
   */
  async sendPhoneCode(phone) {
    try {
      const response = await api.post('/user/phone/verify', { phone })
      return response.data
    } catch (error) {
      console.error('发送手机验证码失败:', error)
      throw error
    }
  },

  /**
   * 验证手机验证码
   * @param {string} phone 手机号
   * @param {string} code 验证码
   * @returns {Promise} 验证结果
   */
  async confirmPhoneCode(phone, code) {
    try {
      const response = await api.post('/user/phone/confirm', { phone, code })
      return response.data
    } catch (error) {
      console.error('验证手机验证码失败:', error)
      throw error
    }
  },

  /**
   * 发送邮箱验证码
   * @param {string} email 邮箱
   * @returns {Promise} 发送结果
   */
  async sendEmailCode(email) {
    try {
      const response = await api.post('/user/email/verify', { email })
      return response.data
    } catch (error) {
      console.error('发送邮箱验证码失败:', error)
      throw error
    }
  },

  /**
   * 验证邮箱验证码
   * @param {string} email 邮箱
   * @param {string} code 验证码
   * @returns {Promise} 验证结果
   */
  async confirmEmailCode(email, code) {
    try {
      const response = await api.post('/user/email/confirm', { email, code })
      return response.data
    } catch (error) {
      console.error('验证邮箱验证码失败:', error)
      throw error
    }
  },

  /**
   * 获取学习统计
   * @returns {Promise} 学习统计数据
   */
  // async getStats() {
  //   try {
  //     const response = await api.get('/user/stats')
  //     return response.data
  //   } catch (error) {
  //     console.error('获取学习统计失败:', error)
  //     throw error
  //   }
  // },

  /**
   * 提交实名认证
   * @param {Object} verificationData 认证数据
   * @returns {Promise} 提交结果
   */
  async submitVerification(verificationData) {
    try {
      const formData = new FormData()
      formData.append('realName', verificationData.realName)
      formData.append('idNumber', verificationData.idNumber)
      
      // 将base64图片转换为文件对象
      if (verificationData.frontImage) {
        const frontFile = await this.dataURLtoFile(verificationData.frontImage, 'front.jpg')
        formData.append('frontImage', frontFile)
      }
      
      if (verificationData.backImage) {
        const backFile = await this.dataURLtoFile(verificationData.backImage, 'back.jpg')
        formData.append('backImage', backFile)
      }
      
      const response = await api.post('/user/verification', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      })
      return response.data
    } catch (error) {
      console.error('提交实名认证失败:', error)
      throw error
    }
  },

  /**
   * 获取实名认证状态
   * @returns {Promise} 认证状态
   */
  async getVerificationStatus() {
    try {
      const response = await api.get('/user/verification/status')
      return response.data
    } catch (error) {
      console.error('获取认证状态失败:', error)
      throw error
    }
  },

  /**
   * 将base64图片转换为文件对象
   * @param {string} dataURL base64图片
   * @param {string} filename 文件名
   * @returns {File} 文件对象
   */
  dataURLtoFile(dataURL, filename) {
    return new Promise((resolve) => {
      const arr = dataURL.split(',')
      const mime = arr[0].match(/:(.*?);/)[1]
      const bstr = atob(arr[1])
      let n = bstr.length
      const u8arr = new Uint8Array(n)
      while (n--) {
        u8arr[n] = bstr.charCodeAt(n)
      }
      resolve(new File([u8arr], filename, { type: mime }))
    })
  }
}

/**
 * 工具函数
 */
export const userUtils = {
  /**
   * 验证邮箱格式
   * @param {string} email 邮箱
   * @returns {boolean} 是否有效
   */
  validateEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
    return emailRegex.test(email)
  },

  /**
   * 验证手机号格式（中国大陆）
   * @param {string} phone 手机号
   * @returns {boolean} 是否有效
   */
  validatePhone(phone) {
    const phoneRegex = /^1[3-9]\d{9}$/
    return phoneRegex.test(phone)
  },

  /**
   * 验证身份证号格式（中国大陆）
   * @param {string} idNumber 身份证号
   * @returns {boolean} 是否有效
   */
  validateIdNumber(idNumber) {
    const idRegex = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/
    return idRegex.test(idNumber)
  },

  /**
   * 验证密码强度
   * @param {string} password 密码
   * @returns {Object} 验证结果
   */
  validatePassword(password) {
    const minLength = password.length >= 6
    const hasLetter = /[a-zA-Z]/.test(password)
    const hasNumber = /\d/.test(password)
    
    return {
      isValid: minLength && hasLetter && hasNumber,
      minLength,
      hasLetter,
      hasNumber
    }
  },

  /**
   * 掩码手机号
   * @param {string} phone 手机号
   * @returns {string} 掩码后的手机号
   */
  maskPhone(phone) {
    if (!phone) return '未绑定'
    return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
  },

  /**
   * 掩码邮箱
   * @param {string} email 邮箱
   * @returns {string} 掩码后的邮箱
   */
  maskEmail(email) {
    if (!email) return '未绑定'
    const [username, domain] = email.split('@')
    return `${username.substring(0, 2)}***@${domain}`
  }
}

export default userApi